<template>
  <div class="amap-picker">
    <div class="map-header">
      <h4>{{ title }}</h4>
      <div class="map-controls">
        <button type="button" class="btn btn-sm btn-secondary" @click="clearMarker">清除标记</button>
        <button type="button" class="btn btn-sm btn-primary" @click="confirmSelection">确认选择</button>
        <button type="button" class="btn btn-sm btn-danger" @click="closeMap">关闭</button>
      </div>
    </div>

    <div class="map-info" v-if="selectedPoint">
      <div class="point-info">
        <span class="point-label">{{ props.mode === 'start' ? '起点' : '终点' }}:</span>
        <span class="point-address">{{ selectedPoint.address }}</span>
      </div>
    </div>

    <div class="map-tips">
      <p>点击地图任意位置选择{{ props.mode === 'start' ? '起点' : '终点' }}</p>
    </div>

    <div id="amap-container" class="map-container"></div>
  </div>
</template>

<script setup lang="ts">
import { ref, onMounted, onUnmounted, defineEmits, defineProps } from 'vue'
import { AMAP_CONFIG, getAMapScriptUrl } from '@/config/map'

interface MapPoint {
  type: 'start' | 'end'
  lng: number
  lat: number
  address: string
  name: string
}

const props = defineProps<{
  title?: string
  mode?: 'start' | 'end' // 新增模式属性
}>()

const emit = defineEmits<{
  confirm: [point: MapPoint] // 修改为单个点
  close: []
}>()

// 响应式数据
const selectedPoint = ref<MapPoint | null>(null)
let map: any = null
let geocoder: any = null
let marker: any = null

onMounted(() => {
  initMap()
})

onUnmounted(() => {
  if (map) {
    map.destroy()
  }
})

const initMap = () => {
  // 检查API Key配置
  if (AMAP_CONFIG.API_KEY === 'YOUR_AMAP_KEY') {
    console.error('请先配置高德地图API Key！')
    alert('请先在 src/config/map.ts 中配置你的高德地图API Key')
    return
  }

  // 检查高德地图是否已加载
  if (typeof window.AMap === 'undefined') {
    loadAMapScript().then(() => {
      createMap()
    }).catch(error => {
      console.error('地图加载失败:', error)
      alert('地图加载失败，请检查网络连接和API Key配置')
    })
  } else {
    createMap()
  }
}

const loadAMapScript = (): Promise<void> => {
  return new Promise((resolve, reject) => {
    if (typeof window.AMap !== 'undefined') {
      resolve()
      return
    }

    const script = document.createElement('script')
    script.src = getAMapScriptUrl()
    script.async = true
    script.onload = () => resolve()
    script.onerror = () => reject(new Error('高德地图加载失败，请检查API Key是否正确'))
    document.head.appendChild(script)
  })
}

const createMap = () => {
  try {
    map = new window.AMap.Map('amap-container', {
      zoom: AMAP_CONFIG.DEFAULT_ZOOM,
      center: AMAP_CONFIG.DEFAULT_CENTER,
      mapStyle: 'amap://styles/normal',
      resizeEnable: true,
      rotateEnable: true,
      pitchEnable: true,
      zoomEnable: true,
      dragEnable: true
    })

    console.log('地图创建成功')

    // 初始化地理编码，配置更详细的参数
    try {
      geocoder = new window.AMap.Geocoder({
        city: '全国',
        radius: 1000, // 搜索半径
        extensions: 'all' // 返回详细信息
      })
      console.log('地理编码器初始化成功')
    } catch (error) {
      console.error('地理编码器初始化失败:', error)
      geocoder = null
    }

    // 等待地图加载完成后添加事件
    map.on('complete', () => {
      console.log('地图加载完成，添加点击事件')
      // 添加地图点击事件
      map.on('click', handleMapClick)

      // 测试地理编码功能
      console.log('测试地理编码功能...')
      geocoder.getAddress([116.397428, 39.90923], (status: string, result: any) => {
        console.log('地理编码测试结果:', status, result)
        if (status !== 'complete') {
          console.error('地理编码服务不可用，可能是API Key权限问题')
        }
      })
    })

    // 添加地图控件
    map.addControl(new window.AMap.Scale())
    map.addControl(new window.AMap.ToolBar())

  } catch (error) {
    console.error('地图创建失败:', error)
  }
}

// 智能地址解析方案 - 优先使用后台精确API
const tryMultipleGeocodingMethods = async (lng: number, lat: number) => {
  console.log(`开始解析坐标: ${lng}, ${lat}`)
  
  // 先设置临时点
  setPoint({
    type: props.mode || 'start',
    lng,
    lat,
    address: '正在获取精确地址...',
    name: '定位中'
  })

  // 优先使用后台地址API服务
  try {
    await callBackendAddressAPI(lng, lat)
    console.log('✅ 后台地址API解析成功')
    return
  } catch (error) {
    console.log('❌ 后台地址API失败，使用本地智能解析:', error)
  }

  // 备用方案：本地智能解析
  const locationInfo = getEnhancedLocationInfo(lng, lat)
  setPoint({
    type: props.mode || 'start',
    lng,
    lat,
    address: locationInfo.fullAddress,
    name: locationInfo.name
  })
  
  console.log('使用本地解析完成:', locationInfo)
}

// 调用后台地址API
const callBackendAddressAPI = (lng: number, lat: number): Promise<void> => {
  return new Promise((resolve, reject) => {
    const url = `http://localhost:5221/api/Address/GetByCoordinate?longitude=${lng}&latitude=${lat}&extensions=all`
    
    console.log('调用后台地址API:', url)
    
    fetch(url, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        // 如果需要认证，在这里添加 Authorization header
      }
    })
      .then(response => {
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
        }
        return response.json()
      })
      .then(data => {
        console.log('后台地址API响应:', data)
        
        if (data.code === 200 && data.data) {
          const addressData = data.data
          
          // 构建完整地址
          const fullAddress = addressData.formattedAddress || 
                             `${addressData.province || ''}${addressData.city || ''}${addressData.district || ''}${addressData.street || ''}${addressData.streetNumber || ''}`
          
          // 构建地点名称 - 优先使用街道+门牌号
          let name = ''
          if (addressData.streetNumber && addressData.street) {
            name = `${addressData.street}${addressData.streetNumber}`
          } else if (addressData.street) {
            name = addressData.street
          } else if (addressData.district) {
            name = `${addressData.district}${props.mode === 'start' ? '起点' : '终点'}`
          } else {
            name = '选中位置'
          }
          
          console.log('解析结果:', {
            address: fullAddress,
            name: name,
            details: addressData
          })
          
          setPoint({
            type: props.mode || 'start',
            lng,
            lat,
            address: fullAddress,
            name: name
          })
          
          resolve()
        } else {
          reject(new Error(`API返回错误: ${data.message || '未知错误'}`))
        }
      })
      .catch(error => {
        console.error('后台地址API调用失败:', error)
        reject(error)
      })
  })
}

// 增强版地址解析
const getEnhancedLocationInfo = (lng: number, lat: number) => {
  // 使用更精确的坐标范围和更多城市数据
  const cityData = getCityByCoordinates(lng, lat)
  const districtData = getDistrictByCoordinates(lng, lat, cityData)
  const streetData = getStreetByCoordinates(lng, lat, districtData)
  
  const fullAddress = `${cityData.province}${cityData.city}${districtData.district}${streetData.street}`
  const name = streetData.landmark || districtData.landmark || `${districtData.district}${props.mode === 'start' ? '起点' : '终点'}`
  
  return {
    fullAddress,
    name,
    province: cityData.province,
    city: cityData.city,
    district: districtData.district,
    street: streetData.street,
    landmark: streetData.landmark
  }
}

// 根据坐标获取城市信息
const getCityByCoordinates = (lng: number, lat: number) => {
  // 北京市
  if (lng >= 115.7 && lng <= 117.4 && lat >= 39.4 && lat <= 41.6) {
    return { province: '北京市', city: '' }
  }
  // 上海市
  else if (lng >= 120.8 && lng <= 122.2 && lat >= 30.7 && lat <= 31.9) {
    return { province: '上海市', city: '' }
  }
  // 天津市
  else if (lng >= 116.8 && lng <= 118.4 && lat >= 38.5 && lat <= 40.3) {
    return { province: '天津市', city: '' }
  }
  // 重庆市
  else if (lng >= 105.2 && lng <= 110.2 && lat >= 28.1 && lat <= 32.2) {
    return { province: '重庆市', city: '' }
  }
  // 广东省
  else if (lng >= 109.7 && lng <= 117.3 && lat >= 20.1 && lat <= 25.5) {
    if (lng >= 113.0 && lng <= 114.8 && lat >= 22.4 && lat <= 23.9) {
      return { province: '广东省', city: '广州市' }
    } else if (lng >= 113.7 && lng <= 114.6 && lat >= 22.4 && lat <= 22.9) {
      return { province: '广东省', city: '深圳市' }
    } else if (lng >= 113.0 && lng <= 113.6 && lat >= 22.6 && lat <= 23.2) {
      return { province: '广东省', city: '佛山市' }
    } else {
      return { province: '广东省', city: '其他城市' }
    }
  }
  // 江苏省
  else if (lng >= 116.2 && lng <= 121.9 && lat >= 30.7 && lat <= 35.3) {
    if (lng >= 118.4 && lng <= 119.2 && lat >= 31.9 && lat <= 32.6) {
      return { province: '江苏省', city: '南京市' }
    } else if (lng >= 120.0 && lng <= 121.0 && lat >= 31.0 && lat <= 31.6) {
      return { province: '江苏省', city: '苏州市' }
    } else {
      return { province: '江苏省', city: '其他城市' }
    }
  }
  // 浙江省
  else if (lng >= 118.0 && lng <= 123.0 && lat >= 27.0 && lat <= 31.4) {
    if (lng >= 119.9 && lng <= 120.9 && lat >= 30.0 && lat <= 30.6) {
      return { province: '浙江省', city: '杭州市' }
    } else if (lng >= 121.3 && lng <= 122.0 && lat >= 29.7 && lat <= 30.1) {
      return { province: '浙江省', city: '宁波市' }
    } else {
      return { province: '浙江省', city: '其他城市' }
    }
  }
  // 山东省
  else if (lng >= 114.8 && lng <= 122.7 && lat >= 34.4 && lat <= 38.4) {
    if (lng >= 116.8 && lng <= 117.4 && lat >= 36.4 && lat <= 37.0) {
      return { province: '山东省', city: '济南市' }
    } else if (lng >= 120.0 && lng <= 120.8 && lat >= 35.8 && lat <= 36.5) {
      return { province: '山东省', city: '青岛市' }
    } else {
      return { province: '山东省', city: '其他城市' }
    }
  }
  // 其他地区
  else {
    return { province: '未知省份', city: '未知城市' }
  }
}

// 根据坐标获取区县信息
const getDistrictByCoordinates = (lng: number, lat: number, cityInfo: any) => {
  // 北京市区县
  if (cityInfo.province === '北京市') {
    if (lng >= 116.2 && lng <= 116.6 && lat >= 39.8 && lat <= 40.1) {
      return { district: '海淀区', landmark: '' }
    } else if (lng >= 116.3 && lng <= 116.5 && lat >= 39.8 && lat <= 40.0) {
      return { district: '西城区', landmark: '' }
    } else if (lng >= 116.4 && lng <= 116.5 && lat >= 39.8 && lat <= 40.0) {
      return { district: '东城区', landmark: '天安门' }
    } else if (lng >= 116.4 && lng <= 116.7 && lat >= 39.8 && lat <= 40.1) {
      return { district: '朝阳区', landmark: '' }
    } else {
      return { district: '其他区', landmark: '' }
    }
  }
  // 上海市区县
  else if (cityInfo.province === '上海市') {
    if (lng >= 121.4 && lng <= 121.5 && lat >= 31.2 && lat <= 31.3) {
      return { district: '黄浦区', landmark: '外滩' }
    } else if (lng >= 121.5 && lng <= 121.6 && lat >= 31.2 && lat <= 31.3) {
      return { district: '浦东新区', landmark: '陆家嘴' }
    } else {
      return { district: '其他区', landmark: '' }
    }
  }
  // 广州市区县
  else if (cityInfo.city === '广州市') {
    if (lng >= 113.3 && lng <= 113.4 && lat >= 23.1 && lat <= 23.2) {
      return { district: '天河区', landmark: '天河城' }
    } else if (lng >= 113.2 && lng <= 113.3 && lat >= 23.1 && lat <= 23.2) {
      return { district: '越秀区', landmark: '北京路' }
    } else {
      return { district: '其他区', landmark: '' }
    }
  }
  // 深圳市区县
  else if (cityInfo.city === '深圳市') {
    if (lng >= 114.0 && lng <= 114.1 && lat >= 22.5 && lat <= 22.6) {
      return { district: '福田区', landmark: '华强北' }
    } else if (lng >= 113.9 && lng <= 114.0 && lat >= 22.5 && lat <= 22.6) {
      return { district: '南山区', landmark: '科技园' }
    } else {
      return { district: '其他区', landmark: '' }
    }
  }
  // 其他城市
  else {
    return { district: '未知区域', landmark: '' }
  }
}

// 根据坐标获取街道信息
const getStreetByCoordinates = (lng: number, lat: number, districtInfo: any) => {
  // 简化的街道识别
  const streetNames = [
    '中山路', '人民路', '解放路', '建设路', '和平路', 
    '胜利路', '光明路', '新华路', '文化路', '团结路',
    '友谊路', '幸福路', '民主路', '自由路', '繁华街',
    '商业街', '步行街', '金融街', '科技路', '创新大道'
  ]
  
  // 根据坐标的小数部分选择街道名
  const index = Math.floor((lng * 1000 + lat * 1000) % streetNames.length)
  const street = streetNames[index]
  
  return {
    street: `${street}附近`,
    landmark: districtInfo.landmark
  }
}

// 高德地理编码方案
const tryAmapGeocoding = (lng: number, lat: number): Promise<void> => {
  return new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      reject(new Error('超时'))
    }, 3000)

    geocoder.getAddress([lng, lat], (status: string, result: any) => {
      clearTimeout(timeout)
      
      if (status === 'complete' && result.regeocode) {
        const regeocode = result.regeocode
        const addressComponent = regeocode.addressComponent
        const formattedAddress = regeocode.formattedAddress
        
        let name = ''
        if (addressComponent.building) {
          name = addressComponent.building
        } else if (regeocode.pois && regeocode.pois.length > 0) {
          name = regeocode.pois[0].name
        } else if (addressComponent.streetNumber && addressComponent.streetNumber.street) {
          name = addressComponent.streetNumber.street
        } else if (addressComponent.neighborhood) {
          name = addressComponent.neighborhood
        } else if (addressComponent.township) {
          name = addressComponent.township
        } else if (addressComponent.district) {
          name = addressComponent.district
        } else {
          const addressParts = formattedAddress.replace(/\s+/g, '').split(/[省市区县]/)
          name = addressParts[addressParts.length - 1] || '选中位置'
        }

        if (!name || name.trim() === '') {
          name = '选中位置'
        }

        setPoint({
          type: props.mode || 'start',
          lng,
          lat,
          address: formattedAddress,
          name: name.trim()
        })
        resolve()
      } else {
        reject(new Error(status))
      }
    })
  })
}

// 高德地图搜索服务方案
const tryAmapSearch = (lng: number, lat: number): Promise<void> => {
  return new Promise((resolve, reject) => {
    // 使用高德地图的PlaceSearch服务
    if (window.AMap && window.AMap.PlaceSearch) {
      const placeSearch = new window.AMap.PlaceSearch({
        pageSize: 1,
        pageIndex: 1,
        city: '全国'
      })
      
      // 搜索附近的地点
      placeSearch.searchNearBy('', [lng, lat], 200, (status: string, result: any) => {
        if (status === 'complete' && result.poiList && result.poiList.pois.length > 0) {
          const poi = result.poiList.pois[0]
          setPoint({
            type: props.mode || 'start',
            lng,
            lat,
            address: poi.address || `经度: ${lng.toFixed(6)}, 纬度: ${lat.toFixed(6)}`,
            name: poi.name || '附近位置'
          })
          resolve()
        } else {
          reject(new Error('搜索失败'))
        }
      })
    } else {
      reject(new Error('PlaceSearch不可用'))
    }
  })
}

// 注意：已移除第三方API调用，现在使用后台API服务

// 详细位置推算方案
const trySimpleLocationNaming = (lng: number, lat: number): Promise<void> => {
  return new Promise((resolve) => {
    const locationInfo = getDetailedLocationInfo(lng, lat)
    
    const address = `${locationInfo.province}${locationInfo.city}${locationInfo.district}${locationInfo.street}`
    const name = locationInfo.landmark || `${locationInfo.district}${props.mode === 'start' ? '起点' : '终点'}`

    setPoint({
      type: props.mode || 'start',
      lng,
      lat,
      address,
      name
    })
    
    resolve()
  })
}

// 获取详细位置信息
const getDetailedLocationInfo = (lng: number, lat: number) => {
  // 北京市详细区域划分
  if (lng >= 116.0 && lng <= 117.0 && lat >= 39.5 && lat <= 40.5) {
    return getBeijingLocationInfo(lng, lat)
  }
  // 上海市详细区域划分
  else if (lng >= 121.0 && lng <= 122.0 && lat >= 31.0 && lat <= 32.0) {
    return getShanghaiLocationInfo(lng, lat)
  }
  // 广州市详细区域划分
  else if (lng >= 113.0 && lng <= 115.0 && lat >= 22.0 && lat <= 24.0) {
    return getGuangzhouLocationInfo(lng, lat)
  }
  // 深圳市详细区域划分
  else if (lng >= 114.0 && lng <= 115.0 && lat >= 22.0 && lat <= 23.0) {
    return getShenzhenLocationInfo(lng, lat)
  }
  // 杭州市详细区域划分
  else if (lng >= 120.0 && lng <= 121.0 && lat >= 30.0 && lat <= 31.0) {
    return getHangzhouLocationInfo(lng, lat)
  }
  // 南京市详细区域划分
  else if (lng >= 118.0 && lng <= 119.0 && lat >= 31.0 && lat <= 33.0) {
    return getNanjingLocationInfo(lng, lat)
  }
  // 其他地区
  else {
    return getGeneralLocationInfo(lng, lat)
  }
}

// 北京市详细位置信息
const getBeijingLocationInfo = (lng: number, lat: number) => {
  let district = ''
  let street = ''
  let landmark = ''
  
  // 天安门广场附近
  if (lng >= 116.39 && lng <= 116.40 && lat >= 39.90 && lat <= 39.91) {
    district = '东城区'
    street = '东华门街道'
    landmark = '天安门广场'
  }
  // 中关村附近
  else if (lng >= 116.30 && lng <= 116.32 && lat >= 39.95 && lat <= 39.97) {
    district = '海淀区'
    street = '中关村街道'
    landmark = '中关村科技园'
  }
  // 王府井附近
  else if (lng >= 116.40 && lng <= 116.42 && lat >= 39.90 && lat <= 39.92) {
    district = '东城区'
    street = '王府井街道'
    landmark = '王府井商业街'
  }
  // 三里屯附近
  else if (lng >= 116.44 && lng <= 116.46 && lat >= 39.93 && lat <= 39.95) {
    district = '朝阳区'
    street = '三里屯街道'
    landmark = '三里屯商圈'
  }
  // 西单附近
  else if (lng >= 116.36 && lng <= 116.38 && lat >= 39.90 && lat <= 39.92) {
    district = '西城区'
    street = '西长安街街道'
    landmark = '西单商圈'
  }
  // 其他北京地区
  else {
    if (lng < 116.4) district = lat > 39.9 ? '海淀区' : '西城区'
    else district = lat > 39.9 ? '朝阳区' : '东城区'
    street = '未知街道'
  }
  
  return {
    province: '北京市',
    city: '',
    district,
    street,
    landmark
  }
}

// 上海市详细位置信息
const getShanghaiLocationInfo = (lng: number, lat: number) => {
  let district = ''
  let street = ''
  let landmark = ''
  
  // 外滩附近
  if (lng >= 121.48 && lng <= 121.50 && lat >= 31.23 && lat <= 31.25) {
    district = '黄浦区'
    street = '外滩街道'
    landmark = '外滩'
  }
  // 陆家嘴附近
  else if (lng >= 121.50 && lng <= 121.52 && lat >= 31.23 && lat <= 31.25) {
    district = '浦东新区'
    street = '陆家嘴街道'
    landmark = '陆家嘴金融区'
  }
  // 南京路附近
  else if (lng >= 121.47 && lng <= 121.49 && lat >= 31.23 && lat <= 31.24) {
    district = '黄浦区'
    street = '南京东路街道'
    landmark = '南京路步行街'
  }
  // 其他上海地区
  else {
    if (lng < 121.5) district = '黄浦区'
    else district = '浦东新区'
    street = '未知街道'
  }
  
  return {
    province: '上海市',
    city: '',
    district,
    street,
    landmark
  }
}

// 广州市详细位置信息
const getGuangzhouLocationInfo = (lng: number, lat: number) => {
  let district = ''
  let street = ''
  let landmark = ''
  
  // 天河区
  if (lng >= 113.32 && lng <= 113.38 && lat >= 23.12 && lat <= 23.16) {
    district = '天河区'
    street = '天河南街道'
    landmark = '天河城商圈'
  }
  // 越秀区
  else if (lng >= 113.25 && lng <= 113.30 && lat >= 23.12 && lat <= 23.15) {
    district = '越秀区'
    street = '北京街道'
    landmark = '北京路商圈'
  }
  // 其他广州地区
  else {
    district = lng > 113.3 ? '天河区' : '越秀区'
    street = '未知街道'
  }
  
  return {
    province: '广东省',
    city: '广州市',
    district,
    street,
    landmark
  }
}

// 深圳市详细位置信息
const getShenzhenLocationInfo = (lng: number, lat: number) => {
  let district = ''
  let street = ''
  let landmark = ''
  
  // 福田区
  if (lng >= 114.05 && lng <= 114.10 && lat >= 22.52 && lat <= 22.55) {
    district = '福田区'
    street = '华强北街道'
    landmark = '华强北商圈'
  }
  // 南山区
  else if (lng >= 113.92 && lng <= 113.98 && lat >= 22.50 && lat <= 22.54) {
    district = '南山区'
    street = '南头街道'
    landmark = '科技园'
  }
  // 其他深圳地区
  else {
    district = lng < 114.0 ? '南山区' : '福田区'
    street = '未知街道'
  }
  
  return {
    province: '广东省',
    city: '深圳市',
    district,
    street,
    landmark
  }
}

// 杭州市详细位置信息
const getHangzhouLocationInfo = (lng: number, lat: number) => {
  let district = ''
  let street = ''
  let landmark = ''
  
  // 西湖区
  if (lng >= 120.12 && lng <= 120.16 && lat >= 30.24 && lat <= 30.28) {
    district = '西湖区'
    street = '西湖街道'
    landmark = '西湖风景区'
  }
  // 上城区
  else if (lng >= 120.16 && lng <= 120.20 && lat >= 30.24 && lat <= 30.27) {
    district = '上城区'
    street = '湖滨街道'
    landmark = '湖滨商圈'
  }
  // 其他杭州地区
  else {
    district = lng < 120.16 ? '西湖区' : '上城区'
    street = '未知街道'
  }
  
  return {
    province: '浙江省',
    city: '杭州市',
    district,
    street,
    landmark
  }
}

// 南京市详细位置信息
const getNanjingLocationInfo = (lng: number, lat: number) => {
  let district = ''
  let street = ''
  let landmark = ''
  
  // 玄武区
  if (lng >= 118.78 && lng <= 118.82 && lat >= 32.04 && lat <= 32.07) {
    district = '玄武区'
    street = '玄武门街道'
    landmark = '玄武湖'
  }
  // 秦淮区
  else if (lng >= 118.78 && lng <= 118.82 && lat >= 32.01 && lat <= 32.04) {
    district = '秦淮区'
    street = '夫子庙街道'
    landmark = '夫子庙'
  }
  // 其他南京地区
  else {
    district = lat > 32.04 ? '玄武区' : '秦淮区'
    street = '未知街道'
  }
  
  return {
    province: '江苏省',
    city: '南京市',
    district,
    street,
    landmark
  }
}

// 其他地区位置信息
const getGeneralLocationInfo = (lng: number, lat: number) => {
  let province = ''
  let city = ''
  let district = ''
  let street = ''
  
  // 根据经纬度判断省份
  if (lng >= 73 && lng <= 135 && lat >= 18 && lat <= 54) {
    if (lng >= 116 && lng <= 117 && lat >= 39 && lat <= 41) {
      province = '北京市'
    } else if (lng >= 121 && lng <= 122 && lat >= 31 && lat <= 32) {
      province = '上海市'
    } else if (lng >= 113 && lng <= 116 && lat >= 22 && lat <= 25) {
      province = '广东省'
      city = lng > 114.5 ? '深圳市' : '广州市'
    } else if (lng >= 118 && lng <= 122 && lat >= 30 && lat <= 35) {
      province = lng > 120 ? '浙江省' : '江苏省'
      city = lng > 120 ? '杭州市' : '南京市'
    } else if (lng < 100) {
      province = '西部地区'
      city = '未知城市'
    } else if (lng > 120) {
      province = '东部地区'
      city = '未知城市'
    } else {
      province = '中部地区'
      city = '未知城市'
    }
    
    district = '未知区域'
    street = '未知街道'
  } else {
    province = '未知区域'
    city = '未知城市'
    district = '未知区域'
    street = '未知街道'
  }
  
  return {
    province,
    city,
    district,
    street,
    landmark: ''
  }
}

// 生成坐标地址
const generateCoordinateAddress = (lng: number, lat: number): string => {
  return `经度: ${lng.toFixed(6)}, 纬度: ${lat.toFixed(6)}`
}

// 生成位置名称
const generateLocationName = (lng: number, lat: number): string => {
  const direction = getDirection(lng, lat)
  return `${direction}${props.mode === 'start' ? '起点' : '终点'}`
}

// 根据坐标获取方位
const getDirection = (lng: number, lat: number): string => {
  // 以北京为中心点参考
  const centerLng = 116.397428
  const centerLat = 39.90923
  
  const isEast = lng > centerLng
  const isNorth = lat > centerLat
  
  if (isNorth && isEast) return '东北方向'
  if (isNorth && !isEast) return '西北方向'
  if (!isNorth && isEast) return '东南方向'
  if (!isNorth && !isEast) return '西南方向'
  return '中心位置'
}

const handleMapClick = (e: any) => {
  console.log('地图被点击:', e)

  try {
    const lng = e.lnglat.getLng()
    const lat = e.lnglat.getLat()

    console.log(`点击坐标: ${lng}, ${lat}`)

    // 尝试多种地址解析方案
    tryMultipleGeocodingMethods(lng, lat)
  } catch (error) {
    console.error('处理地图点击事件时出错:', error)
  }
}

const setPoint = (point: MapPoint) => {
  selectedPoint.value = point
  updateMapMarker()
}

const updateMapMarker = () => {
  // 清除现有标记
  if (marker) {
    map.remove(marker)
    marker = null
  }

  // 添加新标记
  if (selectedPoint.value) {
    const point = selectedPoint.value
    marker = new window.AMap.Marker({
      position: [point.lng, point.lat],
      title: point.address,
      icon: point.type === 'start' ?
        'https://webapi.amap.com/theme/v1.3/markers/n/start.png' :
        'https://webapi.amap.com/theme/v1.3/markers/n/end.png'
    })

    map.add(marker)

    // 调整地图中心到所选点
    map.setCenter([point.lng, point.lat])
  }
}

const clearMarker = () => {
  selectedPoint.value = null
  if (marker) {
    map.remove(marker)
    marker = null
  }
}

const confirmSelection = () => {
  if (!selectedPoint.value) {
    alert('请选择一个点')
    return
  }
  emit('confirm', selectedPoint.value)
}

const closeMap = () => {
  emit('close')
}

// 暴露方法供父组件调用
defineExpose({
  clearMarker
})
</script>

<style scoped>
.amap-picker {
  width: 100%;
  height: 600px;
  border: 1px solid #ddd;
  border-radius: 8px;
  overflow: hidden;
}

.map-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 12px 16px;
  background: #f8f9fa;
  border-bottom: 1px solid #ddd;
}

.map-header h4 {
  margin: 0;
  color: #333;
}

.map-controls {
  display: flex;
  gap: 8px;
}

.map-info {
  padding: 8px 16px;
  background: #fff;
  border-bottom: 1px solid #eee;
  max-height: 80px;
  overflow-y: auto;
}

.point-info {
  display: flex;
  align-items: center;
  margin-bottom: 4px;
  font-size: 14px;
}

.point-label {
  font-weight: 500;
  color: #666;
  min-width: 50px;
}

.point-address {
  color: #333;
  margin-left: 8px;
}

.map-container {
  width: 100%;
  height: calc(100% - 100px);
  cursor: crosshair;
}

.map-tips {
  padding: 8px 16px;
  background: #e3f2fd;
  border-bottom: 1px solid #eee;
  font-size: 14px;
  color: #1976d2;
  text-align: center;
}

.btn {
  padding: 4px 12px;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  font-size: 12px;
  transition: all 0.2s;
}

.btn-primary {
  background: #007bff;
  color: white;
}

.btn-secondary {
  background: #6c757d;
  color: white;
}

.btn-danger {
  background: #dc3545;
  color: white;
}

.btn:hover {
  opacity: 0.8;
}
</style>
